/**
 *   两个数组的比较   内容不能为对象
 * @param {数组1} array
 * @param {数组2} array1
 */
export const arrEquals = (array, array1) => {
  if (!array) return false;

  // compare lengths - can save a lot of time
  if (array1.length != array.length) return false;

  for (var i = 0, l = array1.length; i < l; i++) {
    // Check if we have nested arrays
    if (array1[i] instanceof Array && array[i] instanceof Array) {
      // recurse into the nested arrays
      if (!array1[i].equals(array[i])) return false;
    } else if (array1[i] != array[i]) {
      // Warning - two different object instances will never be equal: {x:20} != {x:20}
      return false;
    }
  }
  return true;
};

/*去重*/

/**
 * 默认数组的去重
 * @param {*} arr
 * @returns { Array } 去重后的数组
 */
export const unique = (arr) => {
  // 如果支持 Set 那么就直接使用Set去重
  if (Array.hasOwnProperty('from')) {
    return Array.from(new Set(arr));
  } else {
    // 没有的话 就只能遍历去重
    var n = {},
      r = [];
    for (var i = 0; i < arr.length; i++) {
      if (!n[arr[i]]) {
        n[arr[i]] = true;
        r.push(arr[i]);
      }
    }
    return r;
  }
  // 注：上面 else 里面的排重并不能区分 2 和 '2'，但能减少用indexOf带来的性能,暂时没找到替代的方法。。。
  /* 正确排重
    if ( Array.hasOwnProperty('from') ) {
        return Array.from(new Set(arr))
    }else{
        var r = [], NaNBol = true
        for(var i=0; i < arr.length; i++) {
            if (arr[i] !== arr[i]) {
                if (NaNBol && r.indexOf(arr[i]) === -1) {
                    r.push(arr[i])
                    NaNBol = false
                }
            }else{
                if(r.indexOf(arr[i]) === -1) r.push(arr[i])
            }
        }
        return r
    }
 
     */
};

/*求两个集合的并集*/
export const union = (a, b) => {
  var newArr = a.concat(b);
  return this.unique(newArr);
};

/*求两个集合的交集*/
export const intersect = (a, b) => {
  var _this = this;
  a = this.unique(a);
  return this.map(a, function(o) {
    return _this.contains(b, o) ? o : null;
  });
};

/**
 * 该方法用于将有父子关系的数组转换成树形结构的数组
 * 接收一个具有父子关系的数组作为参数
 * 返回一个树形结构的数组
 */
export const translateDataToTree = (data, config) => {
  config = config || {
    //
    parentId: 'parentId',
    firstNodeId: 0,
    nodeId: 'id',
    children: 'children'
  };
  let children = [];
  //没有父节点的数据
  let parents = data.filter((value) => {
    if (
      value[config.parentId] == config['firstNodeId'] ||
      value[config.parentId] == null
    ) {
      return value;
    } else {
      // 其他的数据暂时存放在 children 中
      children.push(value);
    }
  });

  //有父节点的数据
  // let children = data.filter(value => value.parentId !== 'undefined' && value.parentId != null);

  //定义转换方法的具体实现
  let translator = (parents, children) => {
    //遍历父节点数据
    parents.forEach((parent) => {
      //遍历子节点数据
      children.forEach((current, index) => {
        //此时找到父节点对应的一个子节点
        if (current[config.parentId] === parent[config.nodeId]) {
          //对子节点数据进行深复制，这里只支持部分类型的数据深复制
          let temp = JSON.parse(JSON.stringify(children));
          //让当前子节点从temp中移除，temp作为新的子节点数据，这里是为了让递归时，子节点的遍历次数更少，如果父子关系的层级越多，越有利
          temp.splice(index, 1);
          //让当前子节点作为唯一的父节点，去递归查找其对应的子节点
          translator([current], temp);
          //把找到子节点放入父节点的children属性中
          typeof parent[config.children] !== 'undefined'
            ? parent[config.children].push(current)
            : (parent[config.children] = [current]);
        }
      });
    });
  };

  //调用转换方法
  translator(parents, children);

  //返回最终的结果
  return parents;
};
